package server

import (
	"data_service/models"
	"errors"
	"fmt"

	"gorm.io/gorm"
)

// FriendService 好友服务
type FriendService struct {
	db *gorm.DB
}

// NewFriendService 创建好友服务实例
func NewFriendService(db *gorm.DB) *FriendService {
	return &FriendService{db: db}
}

// AddFriend 添加好友（双向关系）
func (s *FriendService) AddFriend(userID, friendID uint) error {
	// 检查是否已经是好友
	if models.IsFriend(userID, friendID) {
		return errors.New("已经是好友关系")
	}

	// 检查用户是否存在
	var user, friend models.User
	if err := s.db.First(&user, userID).Error; err != nil {
		return errors.New("用户不存在")
	}
	if err := s.db.First(&friend, friendID).Error; err != nil {
		return errors.New("好友不存在")
	}

	// 不能添加自己为好友
	if userID == friendID {
		return errors.New("不能添加自己为好友")
	}

	// 创建双向好友关系
	friends := []models.Friend{
		{
			UserID:   userID,
			FriendID: friendID,
			Status:   models.FriendStatusActive,
			AddedAt:  models.GetCurrentTime(),
		},
		{
			UserID:   friendID,
			FriendID: userID,
			Status:   models.FriendStatusActive,
			AddedAt:  models.GetCurrentTime(),
		},
	}

	// 使用事务确保数据一致性
	return s.db.Transaction(func(tx *gorm.DB) error {
		for _, friend := range friends {
			if err := tx.Create(&friend).Error; err != nil {
				return fmt.Errorf("创建好友关系失败: %v", err)
			}
		}
		return nil
	})
}

// DeleteFriend 删除好友（双向关系）
func (s *FriendService) DeleteFriend(userID, friendID uint) error {
	// 使用事务删除双向关系
	return s.db.Transaction(func(tx *gorm.DB) error {
		// 删除用户到好友的关系
		if err := tx.Where("user_id = ? AND friend_id = ?", userID, friendID).
			Delete(&models.Friend{}).Error; err != nil {
			return fmt.Errorf("删除好友关系失败: %v", err)
		}

		// 删除好友到用户的关系
		if err := tx.Where("user_id = ? AND friend_id = ?", friendID, userID).
			Delete(&models.Friend{}).Error; err != nil {
			return fmt.Errorf("删除好友关系失败: %v", err)
		}

		return nil
	})
}

// GetFriends 获取用户好友列表
func (s *FriendService) GetFriends(userID uint) ([]models.FriendWithUser, error) {
	var friends []models.Friend

	// 先获取好友关系
	err := s.db.Where("user_id = ? AND status = ?", userID, models.FriendStatusActive).
		Order("created_at DESC").
		Find(&friends).Error

	if err != nil {
		return nil, fmt.Errorf("获取好友列表失败: %v", err)
	}

	// 构建返回结果
	var result []models.FriendWithUser
	for _, friend := range friends {
		fmt.Printf("[GET_FRIENDS] 处理好友关系 - FriendID: %d\n", friend.FriendID)

		// 获取好友用户信息
		var user models.User
		if err := s.db.First(&user, friend.FriendID).Error; err != nil {
			fmt.Printf("[GET_FRIENDS] 用户不存在 - FriendID: %d, 错误: %v\n", friend.FriendID, err)
			// 如果用户不存在，跳过这个好友
			continue
		}

		fmt.Printf("[GET_FRIENDS] 找到用户 - ID: %d, Name: %s, Email: %s\n", user.ID, user.Name, user.Email)

		// 清除密码信息
		user.Password = ""

		// 构建完整的好友信息
		friendWithUser := models.FriendWithUser{
			Friend: friend,
			User:   user,
		}

		result = append(result, friendWithUser)
	}

	return result, nil
}

// SendFriendRequest 发送好友请求
func (s *FriendService) SendFriendRequest(fromUserID, toUserID uint, message string) error {
	// 检查是否已经是好友
	if models.IsFriend(fromUserID, toUserID) {
		return errors.New("已经是好友关系")
	}

	// 检查用户是否存在
	var fromUser, toUser models.User
	if err := s.db.First(&fromUser, fromUserID).Error; err != nil {
		return errors.New("发送者不存在")
	}
	if err := s.db.First(&toUser, toUserID).Error; err != nil {
		return errors.New("接收者不存在")
	}

	// 不能给自己发送好友请求
	if fromUserID == toUserID {
		return errors.New("不能给自己发送好友请求")
	}

	// 检查是否已有待处理的请求
	var existingRequest models.FriendRequest
	err := s.db.Where("from_user_id = ? AND to_user_id = ? AND status = ?",
		fromUserID, toUserID, models.RequestStatusPending).First(&existingRequest).Error
	if err == nil {
		return errors.New("已发送过好友请求，请等待对方处理")
	}

	// 创建好友请求
	request := models.FriendRequest{
		FromUserID: fromUserID,
		ToUserID:   toUserID,
		Message:    message,
		Status:     models.RequestStatusPending,
	}

	if err := s.db.Create(&request).Error; err != nil {
		return fmt.Errorf("发送好友请求失败: %v", err)
	}

	return nil
}

// GetFriendRequests 获取好友请求列表
func (s *FriendService) GetFriendRequests(userID uint, requestType string) ([]models.FriendRequestWithUser, error) {
	var requests []models.FriendRequest
	var query *gorm.DB

	switch requestType {
	case "received":
		// 收到的请求
		query = s.db.Where("to_user_id = ? AND status = ?", userID, models.RequestStatusPending)
	case "sent":
		// 发送的请求
		query = s.db.Where("from_user_id = ? AND status = ?", userID, models.RequestStatusPending)
	default:
		return nil, errors.New("无效的请求类型")
	}

	err := query.Order("created_at DESC").Find(&requests).Error
	if err != nil {
		return nil, fmt.Errorf("获取好友请求失败: %v", err)
	}

	// 构建返回结果
	var result []models.FriendRequestWithUser
	for _, request := range requests {
		var fromUser, toUser models.User

		// 获取发送者信息
		if err := s.db.First(&fromUser, request.FromUserID).Error; err != nil {
			continue
		}
		fromUser.Password = ""

		// 获取接收者信息
		if err := s.db.First(&toUser, request.ToUserID).Error; err != nil {
			continue
		}
		toUser.Password = ""

		// 构建完整的好友请求信息
		requestWithUser := models.FriendRequestWithUser{
			FriendRequest: request,
			FromUser:      fromUser,
			ToUser:        toUser,
		}

		result = append(result, requestWithUser)
	}

	return result, nil
}

// RespondToFriendRequest 处理好友请求
func (s *FriendService) RespondToFriendRequest(requestID uint, userID uint, action string) error {
	var request models.FriendRequest

	// 查找请求
	if err := s.db.First(&request, requestID).Error; err != nil {
		return errors.New("好友请求不存在")
	}

	// 检查权限（只有接收者可以处理请求）
	if request.ToUserID != userID {
		return errors.New("无权限处理此请求")
	}

	// 检查请求状态
	if request.Status != models.RequestStatusPending {
		return errors.New("请求已被处理")
	}

	// 使用事务处理请求
	return s.db.Transaction(func(tx *gorm.DB) error {
		now := models.GetCurrentTime()

		switch action {
		case "accept":
			// 同意请求
			request.Status = models.RequestStatusAccepted
			request.ProcessedAt = &now

			if err := tx.Save(&request).Error; err != nil {
				return fmt.Errorf("更新请求状态失败: %v", err)
			}

			// 创建好友关系
			if err := s.AddFriend(request.FromUserID, request.ToUserID); err != nil {
				return fmt.Errorf("创建好友关系失败: %v", err)
			}

		case "reject":
			// 拒绝请求
			request.Status = models.RequestStatusRejected
			request.ProcessedAt = &now

			if err := tx.Save(&request).Error; err != nil {
				return fmt.Errorf("更新请求状态失败: %v", err)
			}

		default:
			return errors.New("无效的操作")
		}

		return nil
	})
}

// CancelFriendRequest 取消好友请求
func (s *FriendService) CancelFriendRequest(requestID uint, userID uint) error {
	var request models.FriendRequest

	// 查找请求
	if err := s.db.First(&request, requestID).Error; err != nil {
		return errors.New("好友请求不存在")
	}

	// 检查权限（只有发送者可以取消请求）
	if request.FromUserID != userID {
		return errors.New("无权限取消此请求")
	}

	// 检查请求状态
	if request.Status != models.RequestStatusPending {
		return errors.New("请求已被处理，无法取消")
	}

	// 更新请求状态
	now := models.GetCurrentTime()
	request.Status = models.RequestStatusCancelled
	request.ProcessedAt = &now

	if err := s.db.Save(&request).Error; err != nil {
		return fmt.Errorf("取消好友请求失败: %v", err)
	}

	return nil
}

// BlockFriend 拉黑好友
func (s *FriendService) BlockFriend(userID, friendID uint) error {
	// 更新好友状态为拉黑
	if err := s.db.Model(&models.Friend{}).
		Where("user_id = ? AND friend_id = ?", userID, friendID).
		Update("status", models.FriendStatusBlocked).Error; err != nil {
		return fmt.Errorf("拉黑好友失败: %v", err)
	}

	return nil
}

// UnblockFriend 取消拉黑好友
func (s *FriendService) UnblockFriend(userID, friendID uint) error {
	// 更新好友状态为正常
	if err := s.db.Model(&models.Friend{}).
		Where("user_id = ? AND friend_id = ?", userID, friendID).
		Update("status", models.FriendStatusActive).Error; err != nil {
		return fmt.Errorf("取消拉黑失败: %v", err)
	}

	return nil
}

// UpdateFriendRemark 更新好友备注
func (s *FriendService) UpdateFriendRemark(userID, friendID uint, remark string) error {
	if err := s.db.Model(&models.Friend{}).
		Where("user_id = ? AND friend_id = ?", userID, friendID).
		Update("remark", remark).Error; err != nil {
		return fmt.Errorf("更新好友备注失败: %v", err)
	}

	return nil
}

// UpdateFriendGroup 更新好友分组
func (s *FriendService) UpdateFriendGroup(userID, friendID uint, group string) error {
	if err := s.db.Model(&models.Friend{}).
		Where("user_id = ? AND friend_id = ?", userID, friendID).
		Update("group", group).Error; err != nil {
		return fmt.Errorf("更新好友分组失败: %v", err)
	}

	return nil
}
